{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-title"
    ]
   },
   "source": [
    "# Softmax exercise\n",
    "\n",
    "*Complete and hand in this completed worksheet (including its outputs and any supporting code outside of the worksheet) with your assignment submission. For more details see the [assignments page](http://vision.stanford.edu/teaching/cs231n/assignments.html) on the course website.*\n",
    "\n",
    "This exercise is analogous to the SVM exercise. You will:\n",
    "\n",
    "- implement a fully-vectorized **loss function** for the Softmax classifier\n",
    "- implement the fully-vectorized expression for its **analytic gradient**\n",
    "- **check your implementation** with numerical gradient\n",
    "- use a validation set to **tune the learning rate and regularization** strength\n",
    "- **optimize** the loss function with **SGD**\n",
    "- **visualize** the final learned weights\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "tags": [
     "pdf-ignore"
    ]
   },
   "outputs": [],
   "source": [
    "import random\n",
    "import numpy as np\n",
    "from cs231n.data_utils import load_CIFAR10\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "%matplotlib inline\n",
    "plt.rcParams['figure.figsize'] = (10.0, 8.0) # set default size of plots\n",
    "plt.rcParams['image.interpolation'] = 'nearest'\n",
    "plt.rcParams['image.cmap'] = 'gray'\n",
    "\n",
    "# for auto-reloading extenrnal modules\n",
    "# see http://stackoverflow.com/questions/1907993/autoreload-of-modules-in-ipython\n",
    "%load_ext autoreload\n",
    "%autoreload 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "tags": [
     "pdf-ignore"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train data shape:  (49000, 3073)\n",
      "Train labels shape:  (49000,)\n",
      "Validation data shape:  (1000, 3073)\n",
      "Validation labels shape:  (1000,)\n",
      "Test data shape:  (1000, 3073)\n",
      "Test labels shape:  (1000,)\n",
      "dev data shape:  (500, 3073)\n",
      "dev labels shape:  (500,)\n"
     ]
    }
   ],
   "source": [
    "def get_CIFAR10_data(num_training=49000, num_validation=1000, num_test=1000, num_dev=500):\n",
    "    \"\"\"\n",
    "    Load the CIFAR-10 dataset from disk and perform preprocessing to prepare\n",
    "    it for the linear classifier. These are the same steps as we used for the\n",
    "    SVM, but condensed to a single function.  \n",
    "    \"\"\"\n",
    "    # Load the raw CIFAR-10 data\n",
    "    cifar10_dir = 'cs231n/datasets/cifar-10-batches-py'\n",
    "    \n",
    "    # Cleaning up variables to prevent loading data multiple times (which may cause memory issue)\n",
    "    try:\n",
    "       del X_train, y_train\n",
    "       del X_test, y_test\n",
    "       print('Clear previously loaded data.')\n",
    "    except:\n",
    "       pass\n",
    "\n",
    "    X_train, y_train, X_test, y_test = load_CIFAR10(cifar10_dir)\n",
    "    \n",
    "    # subsample the data\n",
    "    mask = list(range(num_training, num_training + num_validation))\n",
    "    X_val = X_train[mask]\n",
    "    y_val = y_train[mask]\n",
    "    mask = list(range(num_training))\n",
    "    X_train = X_train[mask]\n",
    "    y_train = y_train[mask]\n",
    "    mask = list(range(num_test))\n",
    "    X_test = X_test[mask]\n",
    "    y_test = y_test[mask]\n",
    "    mask = np.random.choice(num_training, num_dev, replace=False)\n",
    "    X_dev = X_train[mask]\n",
    "    y_dev = y_train[mask]\n",
    "    \n",
    "    # Preprocessing: reshape the image data into rows\n",
    "    X_train = np.reshape(X_train, (X_train.shape[0], -1))\n",
    "    X_val = np.reshape(X_val, (X_val.shape[0], -1))\n",
    "    X_test = np.reshape(X_test, (X_test.shape[0], -1))\n",
    "    X_dev = np.reshape(X_dev, (X_dev.shape[0], -1))\n",
    "    \n",
    "    # Normalize the data: subtract the mean image\n",
    "    mean_image = np.mean(X_train, axis = 0)\n",
    "    X_train -= mean_image\n",
    "    X_val -= mean_image\n",
    "    X_test -= mean_image\n",
    "    X_dev -= mean_image\n",
    "    \n",
    "    # add bias dimension and transform into columns\n",
    "    X_train = np.hstack([X_train, np.ones((X_train.shape[0], 1))])\n",
    "    X_val = np.hstack([X_val, np.ones((X_val.shape[0], 1))])\n",
    "    X_test = np.hstack([X_test, np.ones((X_test.shape[0], 1))])\n",
    "    X_dev = np.hstack([X_dev, np.ones((X_dev.shape[0], 1))])\n",
    "    \n",
    "    return X_train, y_train, X_val, y_val, X_test, y_test, X_dev, y_dev\n",
    "\n",
    "\n",
    "# Invoke the above function to get our data.\n",
    "X_train, y_train, X_val, y_val, X_test, y_test, X_dev, y_dev = get_CIFAR10_data()\n",
    "print('Train data shape: ', X_train.shape)\n",
    "print('Train labels shape: ', y_train.shape)\n",
    "print('Validation data shape: ', X_val.shape)\n",
    "print('Validation labels shape: ', y_val.shape)\n",
    "print('Test data shape: ', X_test.shape)\n",
    "print('Test labels shape: ', y_test.shape)\n",
    "print('dev data shape: ', X_dev.shape)\n",
    "print('dev labels shape: ', y_dev.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Softmax Classifier\n",
    "\n",
    "Your code for this section will all be written inside **cs231n/classifiers/softmax.py**. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss: 2.382743\n",
      "sanity check: 2.302585\n"
     ]
    }
   ],
   "source": [
    "# First implement the naive softmax loss function with nested loops.\n",
    "# Open the file cs231n/classifiers/softmax.py and implement the\n",
    "# softmax_loss_naive function.\n",
    "\n",
    "from cs231n.classifiers.softmax import softmax_loss_naive\n",
    "import time\n",
    "\n",
    "# Generate a random softmax weight matrix and use it to compute the loss.\n",
    "W = np.random.randn(3073, 10) * 0.0001\n",
    "loss, grad = softmax_loss_naive(W, X_dev, y_dev, 0.0)\n",
    "\n",
    "# As a rough sanity check, our loss should be something close to -log(0.1).\n",
    "print('loss: %f' % loss)\n",
    "print('sanity check: %f' % (-np.log(0.1)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-inline"
    ]
   },
   "source": [
    "**Inline Question 1**\n",
    "\n",
    "Why do we expect our loss to be close to -log(0.1)? Explain briefly.**\n",
    "\n",
    "$\\color{blue}{\\textit Your Answer:}$ Because the w is random choose,and we have 10 classes,so the loos is close to -log(1/10)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "numerical: 2.193297 analytic: 2.193297, relative error: 3.042663e-09\n",
      "numerical: 1.392840 analytic: 1.392840, relative error: 3.734493e-08\n",
      "numerical: 1.169026 analytic: 1.169026, relative error: 2.532976e-09\n",
      "numerical: -0.146758 analytic: -0.146757, relative error: 1.160032e-07\n",
      "numerical: 1.313854 analytic: 1.313854, relative error: 1.240614e-08\n",
      "numerical: 7.289677 analytic: 7.289676, relative error: 1.354307e-08\n",
      "numerical: 0.734578 analytic: 0.734578, relative error: 1.177236e-07\n",
      "numerical: -0.953306 analytic: -0.953306, relative error: 1.177515e-08\n",
      "numerical: -1.990299 analytic: -1.990299, relative error: 1.394879e-08\n",
      "numerical: 0.622146 analytic: 0.622145, relative error: 1.650168e-08\n",
      "numerical: 0.649044 analytic: 0.649044, relative error: 6.933500e-08\n",
      "numerical: 3.096495 analytic: 3.096495, relative error: 8.871355e-09\n",
      "numerical: 0.259331 analytic: 0.259331, relative error: 1.132061e-07\n",
      "numerical: -4.220793 analytic: -4.220793, relative error: 4.708921e-09\n",
      "numerical: -1.037558 analytic: -1.037558, relative error: 5.777815e-08\n",
      "numerical: 2.269427 analytic: 2.269426, relative error: 2.925636e-09\n",
      "numerical: -0.379458 analytic: -0.379458, relative error: 2.251318e-07\n",
      "numerical: 2.452293 analytic: 2.452293, relative error: 2.867661e-08\n",
      "numerical: 0.639193 analytic: 0.639193, relative error: 6.072500e-08\n",
      "numerical: 1.550689 analytic: 1.550688, relative error: 6.280499e-08\n"
     ]
    }
   ],
   "source": [
    "# Complete the implementation of softmax_loss_naive and implement a (naive)\n",
    "# version of the gradient that uses nested loops.\n",
    "loss, grad = softmax_loss_naive(W, X_dev, y_dev, 0.0)\n",
    "\n",
    "# As we did for the SVM, use numeric gradient checking as a debugging tool.\n",
    "# The numeric gradient should be close to the analytic gradient.\n",
    "from cs231n.gradient_check import grad_check_sparse\n",
    "f = lambda w: softmax_loss_naive(w, X_dev, y_dev, 0.0)[0]\n",
    "grad_numerical = grad_check_sparse(f, W, grad, 10)\n",
    "\n",
    "# similar to SVM case, do another gradient check with regularization\n",
    "loss, grad = softmax_loss_naive(W, X_dev, y_dev, 5e1)\n",
    "f = lambda w: softmax_loss_naive(w, X_dev, y_dev, 5e1)[0]\n",
    "grad_numerical = grad_check_sparse(f, W, grad, 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "naive loss: 2.382743e+00 computed in 0.189889s\n",
      "vectorized loss: 2.382743e+00 computed in 0.013994s\n",
      "Loss difference: 0.000000\n",
      "Gradient difference: 0.000000\n"
     ]
    }
   ],
   "source": [
    "# Now that we have a naive implementation of the softmax loss function and its gradient,\n",
    "# implement a vectorized version in softmax_loss_vectorized.\n",
    "# The two versions should compute the same results, but the vectorized version should be\n",
    "# much faster.\n",
    "tic = time.time()\n",
    "loss_naive, grad_naive = softmax_loss_naive(W, X_dev, y_dev, 0.000005)\n",
    "toc = time.time()\n",
    "print('naive loss: %e computed in %fs' % (loss_naive, toc - tic))\n",
    "\n",
    "from cs231n.classifiers.softmax import softmax_loss_vectorized\n",
    "tic = time.time()\n",
    "loss_vectorized, grad_vectorized = softmax_loss_vectorized(W, X_dev, y_dev, 0.000005)\n",
    "toc = time.time()\n",
    "print('vectorized loss: %e computed in %fs' % (loss_vectorized, toc - tic))\n",
    "\n",
    "# As we did for the SVM, we use the Frobenius norm to compare the two versions\n",
    "# of the gradient.\n",
    "grad_difference = np.linalg.norm(grad_naive - grad_vectorized, ord='fro')\n",
    "print('Loss difference: %f' % np.abs(loss_naive - loss_vectorized))\n",
    "print('Gradient difference: %f' % grad_difference)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "tags": [
     "code"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "iteration 0 / 1500: loss 382.425609\n",
      "iteration 100 / 1500: loss 231.168978\n",
      "iteration 200 / 1500: loss 140.254332\n",
      "iteration 300 / 1500: loss 85.664127\n",
      "iteration 400 / 1500: loss 52.573990\n",
      "iteration 500 / 1500: loss 32.644317\n",
      "iteration 600 / 1500: loss 20.496567\n",
      "iteration 700 / 1500: loss 13.147382\n",
      "iteration 800 / 1500: loss 8.779109\n",
      "iteration 900 / 1500: loss 6.085789\n",
      "iteration 1000 / 1500: loss 4.506087\n",
      "iteration 1100 / 1500: loss 3.531537\n",
      "iteration 1200 / 1500: loss 2.968430\n",
      "iteration 1300 / 1500: loss 2.515957\n",
      "iteration 1400 / 1500: loss 2.290110\n",
      "iteration 0 / 1500: loss 779.766957\n",
      "iteration 100 / 1500: loss 285.961395\n",
      "iteration 200 / 1500: loss 105.843543\n",
      "iteration 300 / 1500: loss 40.101191\n",
      "iteration 400 / 1500: loss 16.049501\n",
      "iteration 500 / 1500: loss 7.184730\n",
      "iteration 600 / 1500: loss 3.920069\n",
      "iteration 700 / 1500: loss 2.722434\n",
      "iteration 800 / 1500: loss 2.367460\n",
      "iteration 900 / 1500: loss 2.191382\n",
      "iteration 1000 / 1500: loss 2.145131\n",
      "iteration 1100 / 1500: loss 2.072509\n",
      "iteration 1200 / 1500: loss 2.157061\n",
      "iteration 1300 / 1500: loss 2.066429\n",
      "iteration 1400 / 1500: loss 2.087679\n",
      "iteration 0 / 1500: loss 386.440979\n",
      "iteration 100 / 1500: loss 32.643362\n",
      "iteration 200 / 1500: loss 4.472165\n",
      "iteration 300 / 1500: loss 2.273484\n",
      "iteration 400 / 1500: loss 2.069935\n",
      "iteration 500 / 1500: loss 1.995944\n",
      "iteration 600 / 1500: loss 2.112527\n",
      "iteration 700 / 1500: loss 2.130761\n",
      "iteration 800 / 1500: loss 2.023751\n",
      "iteration 900 / 1500: loss 2.048845\n",
      "iteration 1000 / 1500: loss 2.027731\n",
      "iteration 1100 / 1500: loss 2.046296\n",
      "iteration 1200 / 1500: loss 2.079693\n",
      "iteration 1300 / 1500: loss 2.097704\n",
      "iteration 1400 / 1500: loss 2.028726\n",
      "iteration 0 / 1500: loss 773.573536\n",
      "iteration 100 / 1500: loss 6.897398\n",
      "iteration 200 / 1500: loss 2.135982\n",
      "iteration 300 / 1500: loss 2.059489\n",
      "iteration 400 / 1500: loss 2.008924\n",
      "iteration 500 / 1500: loss 2.044333\n",
      "iteration 600 / 1500: loss 2.087578\n",
      "iteration 700 / 1500: loss 2.091394\n",
      "iteration 800 / 1500: loss 2.059269\n",
      "iteration 900 / 1500: loss 2.111993\n",
      "iteration 1000 / 1500: loss 2.100061\n",
      "iteration 1100 / 1500: loss 2.072597\n",
      "iteration 1200 / 1500: loss 2.048489\n",
      "iteration 1300 / 1500: loss 2.048617\n",
      "iteration 1400 / 1500: loss 2.165157\n",
      "lr 1.000000e-07 reg 2.500000e+04 train accuracy: 0.351694 val accuracy: 0.364000\n",
      "lr 1.000000e-07 reg 5.000000e+04 train accuracy: 0.327714 val accuracy: 0.345000\n",
      "lr 5.000000e-07 reg 2.500000e+04 train accuracy: 0.347633 val accuracy: 0.360000\n",
      "lr 5.000000e-07 reg 5.000000e+04 train accuracy: 0.316959 val accuracy: 0.318000\n",
      "best validation accuracy achieved during cross-validation: 0.364000\n"
     ]
    }
   ],
   "source": [
    "# Use the validation set to tune hyperparameters (regularization strength and\n",
    "# learning rate). You should experiment with different ranges for the learning\n",
    "# rates and regularization strengths; if you are careful you should be able to\n",
    "# get a classification accuracy of over 0.35 on the validation set.\n",
    "from cs231n.classifiers import Softmax\n",
    "results = {}\n",
    "best_val = -1\n",
    "best_softmax = None\n",
    "learning_rates = [1e-7, 5e-7]\n",
    "regularization_strengths = [2.5e4, 5e4]\n",
    "\n",
    "################################################################################\n",
    "# TODO:                                                                        #\n",
    "# Use the validation set to set the learning rate and regularization strength. #\n",
    "# This should be identical to the validation that you did for the SVM; save    #\n",
    "# the best trained softmax classifer in best_softmax.                          #\n",
    "################################################################################\n",
    "# *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n",
    "\n",
    "for rate in learning_rates:\n",
    "    for reg in regularization_strengths:\n",
    "        s=Softmax()\n",
    "        s.train(X_train,y_train,learning_rate=rate,reg=reg,num_iters=1500,verbose=True)\n",
    "        y_train_pred = s.predict(X_train)\n",
    "        y_val_pred = s.predict(X_val)\n",
    "        val=np.mean(y_val == y_val_pred)\n",
    "        if val>best_val:\n",
    "            best_softmax=s\n",
    "            best_val=val\n",
    "        results[(rate,reg)]=(np.mean(y_train == y_train_pred),val)\n",
    "\n",
    "# *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n",
    "    \n",
    "# Print out results.\n",
    "for lr, reg in sorted(results):\n",
    "    train_accuracy, val_accuracy = results[(lr, reg)]\n",
    "    print('lr %e reg %e train accuracy: %f val accuracy: %f' % (\n",
    "                lr, reg, train_accuracy, val_accuracy))\n",
    "    \n",
    "print('best validation accuracy achieved during cross-validation: %f' % best_val)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "softmax on raw pixels final test set accuracy: 0.358000\n"
     ]
    }
   ],
   "source": [
    "# evaluate on test set\n",
    "# Evaluate the best softmax on test set\n",
    "y_test_pred = best_softmax.predict(X_test)\n",
    "test_accuracy = np.mean(y_test == y_test_pred)\n",
    "print('softmax on raw pixels final test set accuracy: %f' % (test_accuracy, ))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-inline"
    ]
   },
   "source": [
    "**Inline Question 2** - *True or False*\n",
    "\n",
    "Suppose the overall training loss is defined as the sum of the per-datapoint loss over all training examples. It is possible to add a new datapoint to a training set that would leave the SVM loss unchanged, but this is not the case with the Softmax classifier loss.\n",
    "\n",
    "$\\color{blue}{\\textit Your Answer:}$ True\n",
    "\n",
    "\n",
    "$\\color{blue}{\\textit Your Explanation:}$ In svm if a datapoint have a clear boundary with groundtruth and other class scores,it is possibly to get 0 loss.But in Softmax no matter what the data are,it will produce loss.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 10 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Visualize the learned weights for each class\n",
    "w = best_softmax.W[:-1,:] # strip out the bias\n",
    "w = w.reshape(32, 32, 3, 10)\n",
    "\n",
    "w_min, w_max = np.min(w), np.max(w)\n",
    "\n",
    "classes = ['plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck']\n",
    "for i in range(10):\n",
    "    plt.subplot(2, 5, i + 1)\n",
    "    \n",
    "    # Rescale the weights to be between 0 and 255\n",
    "    wimg = 255.0 * (w[:, :, :, i].squeeze() - w_min) / (w_max - w_min)\n",
    "    plt.imshow(wimg.astype('uint8'))\n",
    "    plt.axis('off')\n",
    "    plt.title(classes[i])"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
